Built with doc-gen4, running Lean4. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑Ctrl+↓to navigate, Ctrl+πŸ–±οΈto focus. On Mac, use Cmdinstead of Ctrl.
import Mathlib.Data.Vector
import Mathlib.Data.Bitvec.Basic
import Mathlib.Algebra.Group.InjSurj
import Mathlib.Tactic.Ring
import Mathlib.Data.Int.Cast.Lemmas
import Mathlib.Data.ZMod.Basic

namespace Vector

instance: {Ξ± : Type u} β†’ {n : β„•} β†’ GetElem (Vector Ξ± n) (Fin n) Ξ± fun x x => True
instance
{
Ξ±: Type u
Ξ±
:
Type u: Type (u+1)
Type u
} {n :
Nat: Type
Nat
} :
GetElem: (cont : Type ?u.8) β†’ (idx : Type ?u.7) β†’ outParam (Type ?u.6) β†’ outParam (cont β†’ idx β†’ Prop) β†’ Type (max(max?u.8?u.7)?u.6)
GetElem
(
Vector: Type ?u.9 β†’ β„• β†’ Type ?u.9
Vector
Ξ±: Type u
Ξ±
n) (
Fin: β„• β†’ Type
Fin
n)
Ξ±: Type u
Ξ±
(fun
_: ?m.11
_
_: ?m.14
_
=>
True: Prop
True
) where getElem := fun
v: ?m.45
v
i: ?m.48
i
_: ?m.51
_
=>
v: ?m.45
v
.
1: {Ξ± : Sort ?u.62} β†’ {p : Ξ± β†’ Prop} β†’ Subtype p β†’ Ξ±
1
[
i: ?m.48
i
.
val: {n : β„•} β†’ Fin n β†’ β„•
val
] @[simp] theorem
getElem_eq_get: βˆ€ {Ξ± : Type u} {n : β„•} (v : Vector Ξ± n) (i : Fin n), v[i] = get v i
getElem_eq_get
{
Ξ±: Type u
Ξ±
:
Type u: Type (u+1)
Type u
} {n :
Nat: Type
Nat
} (
v: Vector Ξ± n
v
:
Vector: Type ?u.634 β†’ β„• β†’ Type ?u.634
Vector
Ξ±: Type u
Ξ±
n) (
i: Fin n
i
:
Fin: β„• β†’ Type
Fin
n) :
v: Vector Ξ± n
v
[
i: Fin n
i
] =
v: Vector Ξ± n
v
.
get: {Ξ± : Type ?u.689} β†’ {n : β„•} β†’ Vector Ξ± n β†’ Fin n β†’ Ξ±
get
i: Fin n
i
:=
rfl: βˆ€ {Ξ± : Sort ?u.817} {a : Ξ±}, a = a
rfl
end Vector namespace Bitvec def
width: {n : β„•} β†’ Bitvec n β†’ β„•
width
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.869
n
β†’
Nat: Type
Nat
:= fun
_: ?m.877
_
=> n -- Shouldn't this be inferred from the instance above? (as Bitvec is @[reducible])
instance: {n : β„•} β†’ GetElem (Bitvec n) (Fin n) Bool fun x x => True
instance
{n :
Nat: Type
Nat
} :
GetElem: (cont : Type ?u.917) β†’ (idx : Type ?u.916) β†’ outParam (Type ?u.915) β†’ outParam (cont β†’ idx β†’ Prop) β†’ Type (max(max?u.917?u.916)?u.915)
GetElem
(
Bitvec: β„• β†’ Type
Bitvec
n) (
Fin: β„• β†’ Type
Fin
n)
Bool: Type
Bool
(fun
_: ?m.919
_
_: ?m.922
_
=>
True: Prop
True
) where getElem := fun
v: ?m.948
v
i: ?m.951
i
_: ?m.954
_
=>
v: ?m.948
v
.
1: {Ξ± : Sort ?u.965} β†’ {p : Ξ± β†’ Prop} β†’ Subtype p β†’ Ξ±
1
[
i: ?m.951
i
.
val: {n : β„•} β†’ Fin n β†’ β„•
val
]
instance: (n : β„•) β†’ Inhabited (Bitvec n)
instance
(n :
Nat: Type
Nat
) :
Inhabited: Sort ?u.1488 β†’ Sort (max1?u.1488)
Inhabited
(
Bitvec: β„• β†’ Type
Bitvec
n) := ⟨
List.replicate: {Ξ± : Type ?u.1508} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate
n
true: Bool
true
,

Goals accomplished! πŸ™

Goals accomplished! πŸ™
⟩ def
Fun: (width : β„•) β†’ ?m.1584 width
Fun
(
width: β„•
width
:
Nat: Type
Nat
) :=
Fin: β„• β†’ Type
Fin
width: β„•
width
β†’
Bool: Type
Bool
def
ofInt': (n : β„•) β†’ β„€ β†’ Bitvec n
ofInt'
(n :
Nat: Type
Nat
) (z :
Int: Type
Int
) :
Bitvec: β„• β†’ Type
Bitvec
n := match n with | 0 => ⟨
List.nil: {Ξ± : Type ?u.1633} β†’ List Ξ±
List.nil
,
rfl: βˆ€ {Ξ± : Sort ?u.1636} {a : Ξ±}, a = a
rfl
⟩ | m + 1 =>
Bitvec.ofInt: (n : β„•) β†’ β„€ β†’ Bitvec (Nat.succ n)
Bitvec.ofInt
m z /-- convert `Bitvec n` to `Fin n β†’ Bool` -/ def
ofFun: {width : β„•} β†’ Fun width β†’ Bitvec width
ofFun
{
width: β„•
width
:
Nat: Type
Nat
} :
Fun: β„• β†’ Type
Fun
width: β„•
width
β†’
Bitvec: β„• β†’ Type
Bitvec
width: β„•
width
:=
Vector.ofFn: {Ξ± : Type ?u.1904} β†’ {n : β„•} β†’ (Fin n β†’ Ξ±) β†’ Vector Ξ± n
Vector.ofFn
/-- convert `Fin n β†’ Bool` to `Bitvec n` -/ def
toFun: {width : β„•} β†’ Bitvec width β†’ Fun width
toFun
{
width: β„•
width
:
Nat: Type
Nat
} :
Bitvec: β„• β†’ Type
Bitvec
width: β„•
width
β†’
Fun: β„• β†’ Type
Fun
width: β„•
width
:=
Vector.get: {Ξ± : Type ?u.1958} β†’ {n : β„•} β†’ Vector Ξ± n β†’ Fin n β†’ Ξ±
Vector.get
instance: {width : β„•} β†’ Coe (Fun width) (Bitvec width)
instance
{
width: β„•
width
:
Nat: Type
Nat
} :
Coe: semiOutParam (Sort ?u.2016) β†’ Sort ?u.2015 β†’ Sort (max(max1?u.2016)?u.2015)
Coe
(
Fun: β„• β†’ Type
Fun
width: β„•
width
) (
Bitvec: β„• β†’ Type
Bitvec
width: β„•
width
) := ⟨@
ofFun: {width : β„•} β†’ Fun width β†’ Bitvec width
ofFun
width: β„•
width
⟩
instance: {width : β„•} β†’ Coe (Bitvec width) (Fun width)
instance
{
width: β„•
width
:
Nat: Type
Nat
} :
Coe: semiOutParam (Sort ?u.2097) β†’ Sort ?u.2096 β†’ Sort (max(max1?u.2097)?u.2096)
Coe
(
Bitvec: β„• β†’ Type
Bitvec
width: β„•
width
) (
Fun: β„• β†’ Type
Fun
width: β„•
width
) := ⟨@
toFun: {width : β„•} β†’ Bitvec width β†’ Fun width
toFun
width: β„•
width
⟩ def
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector
:
Vector: Type ?u.2179 β†’ β„• β†’ Type ?u.2179
Vector
Bool: Type
Bool
n: ?m.2175
n
β†’
Bitvec: β„• β†’ Type
Bitvec
n: ?m.2175
n
:=
id: {Ξ± : Sort ?u.2185} β†’ Ξ± β†’ Ξ±
id
-- inspired by: https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Defining.20my.20own.20numerals -- not ideal solution, as hard to type, but should be ok for now prefix:max "𝟢" => fun v =>
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector
(
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons
false: Bool
false
v) prefix:max "𝟷" => fun v =>
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector
(
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons
true: Bool
true
v) notation:max "𝟢" =>
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector
(
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons
false: Bool
false
(@
Vector.nil: {Ξ± : Type u} β†’ Vector Ξ± 0
Vector.nil
Bool: Type
Bool
)) notation:max "𝟷" =>
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector
(
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons
true: Bool
true
(@
Vector.nil: {Ξ± : Type u} β†’ Vector Ξ± 0
Vector.nil
Bool: Type
Bool
))
instance: {n : β„•} β†’ Add (Bitvec n)
instance
:
Add: Type ?u.125046 β†’ Type ?u.125046
Add
(
Bitvec: β„• β†’ Type
Bitvec
n: ?m.125043
n
) where add :=
Bitvec.add: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
Bitvec.add
instance: {n : β„•} β†’ Sub (Bitvec n)
instance
:
Sub: Type ?u.125140 β†’ Type ?u.125140
Sub
(
Bitvec: β„• β†’ Type
Bitvec
n: ?m.125137
n
) where sub :=
Bitvec.sub: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
Bitvec.sub
-- examples: -- #eval (𝟷𝟢𝟷𝟷).toNat -- #eval (𝟢𝟷𝟷𝟷).toNat -- #eval (𝟢𝟷𝟷𝟷) + (𝟷𝟢𝟷𝟷) |>.toNat -- #eval 𝟷𝟢𝟷𝟷 + 𝟢𝟷𝟷𝟷 -- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) true -- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) false -- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) true |>.toNat -- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) false |>.toNat -- -- #eval Bitvec.adc (𝟢) (𝟢) true -- #eval Bitvec.adc (𝟢) (𝟢) false def
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
{n :
Nat: Type
Nat
} (
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n) :
ZMod: β„• β†’ Type
ZMod
(
2: ?m.125237
2
^ n) :=
x: Bitvec n
x
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
theorem
toZMod_val: βˆ€ {n : β„•} (v : Bitvec n), ZMod.val (toZMod v) = Bitvec.toNat v
toZMod_val
{n :
β„•: Type
β„•
} (
v: Bitvec n
v
:
Bitvec: β„• β†’ Type
Bitvec
n) : (
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
v: Bitvec n
v
).
val: {n : β„•} β†’ ZMod n β†’ β„•
val
=
v: Bitvec n
v
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
:=

Goals accomplished! πŸ™

Goals accomplished! πŸ™
def
ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
ofZMod
{n :
β„•: Type
β„•
} (
x: ZMod (2 ^ n)
x
:
ZMod: β„• β†’ Type
ZMod
(
2: ?m.125994
2
^ n)) :
Bitvec: β„• β†’ Type
Bitvec
n :=
Bitvec.ofNat: (n : β„•) β†’ β„• β†’ Bitvec n
Bitvec.ofNat
_
x: ZMod (2 ^ n)
x
.
val: {n : β„•} β†’ ZMod n β†’ β„•
val
theorem
toZMod_ofZMod: βˆ€ {n : β„•} (i : ZMod (2 ^ n)), toZMod (ofZMod i) = i
toZMod_ofZMod
{
n: ?m.126151
n
} (
i: ZMod (2 ^ n)
i
:
ZMod: β„• β†’ Type
ZMod
<|
2: ?m.126158
2
^
n: ?m.126151
n
) : (
ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
ofZMod
i: ZMod (2 ^ n)
i
).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
=
i: ZMod (2 ^ n)
i
:=
ZMod.val_injective: βˆ€ (n : β„•) [inst : NeZero n], Function.Injective ZMod.val
ZMod.val_injective
_ (

Goals accomplished! πŸ™

Goals accomplished! πŸ™
) theorem
ofZMod_toZMod: βˆ€ {n : β„•} (v : Bitvec n), ofZMod (toZMod v) = v
ofZMod_toZMod
{n} (
v: Bitvec n
v
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.126550
n
) :
ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
ofZMod
(
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
v: Bitvec n
v
) =
v: Bitvec n
v
:=

Goals accomplished! πŸ™
n: β„•

v: Bitvec n


v = v

Goals accomplished! πŸ™
theorem
foldl_addLsb_add: βˆ€ (n k : β„•) (x : List Bool), List.foldl addLsb (n + k) x = 2 ^ List.length x * k + List.foldl addLsb n x
foldl_addLsb_add
: βˆ€ (n k :
β„•: Type
β„•
) (x :
List: Type ?u.126633 β†’ Type ?u.126633
List
Bool: Type
Bool
), x.
foldl: {Ξ± : Type ?u.126638} β†’ {Ξ² : Type ?u.126637} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
(n + k) =
2: ?m.126703
2
^ x.
length: {Ξ± : Type ?u.126712} β†’ List Ξ± β†’ β„•
length
* k + x.
foldl: {Ξ± : Type ?u.126717} β†’ {Ξ² : Type ?u.126716} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
n | n, k, [] =>

Goals accomplished! πŸ™
n, k: β„•



Goals accomplished! πŸ™
| n, k,
a: Bool
a
::l =>

Goals accomplished! πŸ™
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (addLsb (n + k) a) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (addLsb (n + k) a) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (addLsb n a) l
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (addLsb n a) l
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l

Goals accomplished! πŸ™
n, k: β„•

a: Bool

l: List Bool


(n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)

Goals accomplished! πŸ™
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)


List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)


List.foldl addLsb ((n + n + bif a then 1 else 0) + (k + k)) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)


List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)


2 ^ List.length l * (k + k) + List.foldl addLsb (n + n + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)


2 ^ List.length l * (k + k) + List.foldl addLsb (n + n + bif a then 1 else 0) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool


List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)

Goals accomplished! πŸ™
theorem
foldl_addLsb_eq_add_foldl_addLsb_zero: βˆ€ (x : List Bool) (k : β„•), List.foldl addLsb k x = 2 ^ List.length x * k + List.foldl addLsb 0 x
foldl_addLsb_eq_add_foldl_addLsb_zero
(x :
List: Type ?u.129331 β†’ Type ?u.129331
List
Bool: Type
Bool
) (k :
β„•: Type
β„•
) : x.
foldl: {Ξ± : Type ?u.129338} β†’ {Ξ² : Type ?u.129337} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
k =
2: ?m.129363
2
^ x.
length: {Ξ± : Type ?u.129372} β†’ List Ξ± β†’ β„•
length
* k + x.
foldl: {Ξ± : Type ?u.129377} β†’ {Ξ² : Type ?u.129376} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.129392
0
:=

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
foldl_addLsb_cons_zero: βˆ€ (a : Bool) (x : List Bool), List.foldl addLsb 0 (a :: x) = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x
foldl_addLsb_cons_zero
(
a: Bool
a
:
Bool: Type
Bool
) (x :
List: Type ?u.129684 β†’ Type ?u.129684
List
Bool: Type
Bool
) : (
a: Bool
a
::x).
foldl: {Ξ± : Type ?u.129692} β†’ {Ξ² : Type ?u.129691} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.129707
0
=
2: ?m.129727
2
^x.
length: {Ξ± : Type ?u.129736} β†’ List Ξ± β†’ β„•
length
*
cond: {Ξ± : Type ?u.129740} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond
a: Bool
a
1: ?m.129743
1
0: ?m.129753
0
+ x.
foldl: {Ξ± : Type ?u.129761} β†’ {Ξ² : Type ?u.129760} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.129776
0
:= calc (
a: Bool
a
::x).
foldl: {Ξ± : Type ?u.129929} β†’ {Ξ² : Type ?u.129928} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.129944
0
= x.
foldl: {Ξ± : Type ?u.129947} β†’ {Ξ² : Type ?u.129946} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
(
0: ?m.129968
0
+
0: ?m.129979
0
+
cond: {Ξ± : Type ?u.129989} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond
a: Bool
a
1: ?m.129992
1
0: ?m.130002
0
) :=
rfl: βˆ€ {Ξ± : Sort ?u.130072} {a : Ξ±}, a = a
rfl
_: ?m✝
_
=
_: ?m.130127
_
:=

Goals accomplished! πŸ™

List.foldl addLsb (0 + 0 + bif a then 1 else 0) x = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x

List.foldl addLsb (0 + 0 + bif a then 1 else 0) x = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x

(2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb (0 + 0) x = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x

Goals accomplished! πŸ™
theorem
toNat_adc_aux: βˆ€ {x y : List Bool}, List.length x = List.length y β†’ List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd = List.foldl addLsb 0 x + List.foldl addLsb 0 y
toNat_adc_aux
: βˆ€ {x y:
List: Type ?u.130236 β†’ Type ?u.130236
List
Bool: Type
Bool
} (_h :
List.length: {Ξ± : Type ?u.130240} β†’ List Ξ± β†’ β„•
List.length
x =
List.length: {Ξ± : Type ?u.130244} β†’ List Ξ± β†’ β„•
List.length
y),
List.foldl: {Ξ± : Type ?u.130252} β†’ {Ξ² : Type ?u.130251} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
(
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.130262
0
(
List.mapAccumrβ‚‚: {Ο† : Type ?u.130275} β†’ {Οƒ : Type ?u.130274} β†’ {Ξ± : Type ?u.130273} β†’ {Ξ² : Type ?u.130272} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚
(fun
x: ?m.130281
x
y: ?m.130284
y
c: ?m.130287
c
=> (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry
x: ?m.130281
x
y: ?m.130284
y
c: ?m.130287
c
,
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3
x: ?m.130281
x
y: ?m.130284
y
c: ?m.130287
c
)) x y
false: Bool
false
).
fst: {Ξ± : Type ?u.130306} β†’ {Ξ² : Type ?u.130305} β†’ Ξ± Γ— Ξ² β†’ Ξ±
fst
) (
List.mapAccumrβ‚‚: {Ο† : Type ?u.130312} β†’ {Οƒ : Type ?u.130311} β†’ {Ξ± : Type ?u.130310} β†’ {Ξ² : Type ?u.130309} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚
(fun
x: ?m.130318
x
y: ?m.130321
y
c: ?m.130324
c
=> (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry
x: ?m.130318
x
y: ?m.130321
y
c: ?m.130324
c
,
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3
x: ?m.130318
x
y: ?m.130321
y
c: ?m.130324
c
)) x y
false: Bool
false
).
snd: {Ξ± : Type ?u.130341} β†’ {Ξ² : Type ?u.130340} β†’ Ξ± Γ— Ξ² β†’ Ξ²
snd
=
List.foldl: {Ξ± : Type ?u.130348} β†’ {Ξ² : Type ?u.130347} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.130358
0
x +
List.foldl: {Ξ± : Type ?u.130361} β†’ {Ξ² : Type ?u.130360} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.130371
0
y | [], [], _ =>
rfl: βˆ€ {Ξ± : Sort ?u.130456} {a : Ξ±}, a = a
rfl
|
a: Bool
a
::x,
b: Bool
b
::y,
h: List.length (a :: x) = List.length (b :: y)
h
=>

Goals accomplished! πŸ™

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x + ((2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb 0 y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (List.foldl addLsb 0 x + List.foldl addLsb 0 y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).fst) (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).snd = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd

List.foldl addLsb (addLsb 0 (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).fst) (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).snd = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)) (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

List.foldl addLsb (addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)) (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + List.foldl addLsb 0 (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd

List.foldl addLsb (addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)) (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd

List.foldl addLsb (addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)) (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd = List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)

false
2 ^ List.length (xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (false && b || false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

true
2 ^ List.length (xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (true && b || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

false
2 ^ List.length (xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (false && b || false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

true
2 ^ List.length (xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (true && b || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

true.false
2 ^ List.length (xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (true && false || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif false then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

true.true
2 ^ List.length (xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (true && true || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif true then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

false.false
2 ^ List.length (xor (xor false false) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (false && false || false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false false) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif false then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

false.true
2 ^ List.length (xor (xor false true) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (false && true || false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false true) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif true then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

true.false
2 ^ List.length (xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (true && false || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif false then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

true.true
2 ^ List.length (xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (true && true || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif true then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

false.true
(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

false.true
(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

true.false
(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

true.false.false
(2 ^ List.length y * bif false then 0 else 1) + ((2 ^ List.length y * bif false then 1 else 0) + ((2 ^ List.length y * bif false then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif false then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

true.false.true
(2 ^ List.length y * bif true then 0 else 1) + ((2 ^ List.length y * bif true then 1 else 0) + ((2 ^ List.length y * bif true then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif true then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

false.true.false
(2 ^ List.length y * bif false then 0 else 1) + ((2 ^ List.length y * bif false then 1 else 0) + ((2 ^ List.length y * bif false then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif false then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

false.true.true
(2 ^ List.length y * bif true then 0 else 1) + ((2 ^ List.length y * bif true then 1 else 0) + ((2 ^ List.length y * bif true then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif true then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

true.false.false
(2 ^ List.length y * bif false then 0 else 1) + ((2 ^ List.length y * bif false then 1 else 0) + ((2 ^ List.length y * bif false then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif false then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

true.false.true
(2 ^ List.length y * bif true then 0 else 1) + ((2 ^ List.length y * bif true then 1 else 0) + ((2 ^ List.length y * bif true then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) = 2 ^ List.length y + ((2 ^ List.length y * bif true then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)

2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) * addLsb 0 (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) = ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) + (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd * addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)

Goals accomplished! πŸ™
theorem
toNat_adc: βˆ€ {n : β„•} {x y : Bitvec n}, Bitvec.toNat (adc x y false) = Bitvec.toNat x + Bitvec.toNat y
toNat_adc
{n :
Nat: Type
Nat
} {
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n} : (
Bitvec.adc: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bool β†’ Bitvec (n + 1)
Bitvec.adc
x: Bitvec n
x
y: Bitvec n
y
false: Bool
false
).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
=
x: Bitvec n
x
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
+
y: Bitvec n
y
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
:=

Goals accomplished! πŸ™

mk
Bitvec.toNat (adc { val := x, property := hx } y false) = Bitvec.toNat { val := x, property := hx } + Bitvec.toNat y

mk.mk
Bitvec.toNat (adc { val := x, property := hx } { val := y, property := hy } false) = Bitvec.toNat { val := x, property := hx } + Bitvec.toNat { val := y, property := hy }

mk.mk
Bitvec.toNat (adc { val := x, property := (_ : List.length x = List.length x) } { val := y, property := hy } false) = Bitvec.toNat { val := x, property := (_ : List.length x = List.length x) } + Bitvec.toNat { val := y, property := hy }

mk.mk
List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst) (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd = List.foldl addLsb 0 x + List.foldl addLsb 0 y

Goals accomplished! πŸ™
theorem
toNat_tail: βˆ€ {n : β„•} (x : Bitvec n), Bitvec.toNat (Vector.tail x) = Bitvec.toNat x % 2 ^ (n - 1)
toNat_tail
: βˆ€ {n :
Nat: Type
Nat
} (
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n),
Bitvec.toNat: {n : β„•} β†’ Bitvec n β†’ β„•
Bitvec.toNat
x: Bitvec n
x
.
tail: {Ξ± : Type ?u.143473} β†’ {n : β„•} β†’ Vector Ξ± n β†’ Vector Ξ± (n - 1)
tail
=
x: Bitvec n
x
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
%
2: ?m.143492
2
^(n-
1: ?m.143505
1
) | 0, ⟨[], _⟩ =>
rfl: βˆ€ {Ξ± : Sort ?u.143701} {a : Ξ±}, a = a
rfl
| n+1, ⟨
a: Bool
a
::l,
h: List.length (a :: l) = n + 1
h
⟩ =>

Goals accomplished! πŸ™
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) = Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) = Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h })
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) = Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n


Bitvec.toNat (Vector.tail { val := a :: l, property := h✝ }) % 2 ^ (n + 1 - 1) = Bitvec.toNat { val := a :: l, property := h✝ } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) = Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n


List.foldl addLsb 0 ↑(Vector.tail { val := a :: l, property := h✝ }) % 2 ^ (n + 1 - 1) = ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) = Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n


List.foldl addLsb 0 l % 2 ^ n = ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1


Bitvec.toNat (Vector.tail { val := a :: l, property := h }) = Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n


List.foldl addLsb 0 l % 2 ^ n = ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n


List.foldl addLsb 0 l % 2 ^ n = ((bif a then 1 else 0) * 2 ^ n + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n


List.foldl addLsb 0 l % 2 ^ n = ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n



Goals accomplished! πŸ™
@[simp] theorem
toNat_add: βˆ€ {n : β„•} (x y : Bitvec n), Bitvec.toNat (x + y) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
toNat_add
{n :
Nat: Type
Nat
} (
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n) : (
x: Bitvec n
x
+
y: Bitvec n
y
).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
= (
x: Bitvec n
x
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
+
y: Bitvec n
y
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
) %
2: ?m.146225
2
^n :=

Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n


Bitvec.toNat (adc x y false) % 2 ^ (n + 1 - 1) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n


(Bitvec.toNat x + Bitvec.toNat y) % 2 ^ (n + 1 - 1) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n

Goals accomplished! πŸ™
theorem
toZMod_add: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x + y) = toZMod x + toZMod y
toZMod_add
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n) : (
x: Bitvec n
x
+
y: Bitvec n
y
).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
= (
x: Bitvec n
x
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
+
y: Bitvec n
y
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
) :=

Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n


toZMod (x + y) = toZMod x + toZMod y
n: β„•

x, y: Bitvec n


a
n: β„•

x, y: Bitvec n


toZMod (x + y) = toZMod x + toZMod y
n: β„•

x, y: Bitvec n


a
n: β„•

x, y: Bitvec n


a
n: β„•

x, y: Bitvec n


a
n: β„•

x, y: Bitvec n


a
n: β„•

x, y: Bitvec n


a
n: β„•

x, y: Bitvec n


a
n: β„•

x, y: Bitvec n


a

Goals accomplished! πŸ™
theorem
ofZMod_add: βˆ€ {n : β„•} (x y : ZMod (2 ^ n)), ofZMod (x + y) = ofZMod x + ofZMod y
ofZMod_add
{n :
β„•: Type
β„•
} (
x: ZMod (2 ^ n)
x
y: ZMod (2 ^ n)
y
:
ZMod: β„• β†’ Type
ZMod
(
2: ?m.147846
2
^n)) :
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod
(
x: ZMod (2 ^ n)
x
+
y: ZMod (2 ^ n)
y
) =
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod
x: ZMod (2 ^ n)
x
+
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod
y: ZMod (2 ^ n)
y
:=

Goals accomplished! πŸ™
n: β„•

x, y: ZMod (2 ^ n)


ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)


ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)


n: β„•

x, y: ZMod (2 ^ n)


ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)


ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)


ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)


n: β„•

x, y: ZMod (2 ^ n)


ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)


n: β„•

x, y: ZMod (2 ^ n)


ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)



Goals accomplished! πŸ™
theorem
zero_def: βˆ€ {n : β„•}, 0 = { val := List.replicate n false, property := (_ : List.length ↑0 = n) }
zero_def
: (
0: ?m.148270
0
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.148264
n
) = ⟨
List.replicate: {Ξ± : Type ?u.148313} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate
n: ?m.148264
n
false: Bool
false
, (
0: ?m.148318
0
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.148264
n
).
2: βˆ€ {Ξ± : Sort ?u.148320} {p : Ξ± β†’ Prop} (self : Subtype p), p ↑self
2
⟩ :=
rfl: βˆ€ {Ξ± : Sort ?u.148341} {a : Ξ±}, a = a
rfl
theorem
toList_zero: βˆ€ {n : β„•}, Vector.toList 0 = List.replicate n false
toList_zero
:
Vector.toList: {Ξ± : Type ?u.148361} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
Vector.toList
(
0: ?m.148366
0
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.148357
n
) =
List.replicate: {Ξ± : Type ?u.148395} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate
n: ?m.148357
n
false: Bool
false
:=
rfl: βˆ€ {Ξ± : Sort ?u.148401} {a : Ξ±}, a = a
rfl
@[simp] theorem
toNat_zero: βˆ€ {n : β„•}, Bitvec.toNat 0 = 0
toNat_zero
: βˆ€ {n :
Nat: Type
Nat
}, (
0: ?m.148433
0
:
Bitvec: β„• β†’ Type
Bitvec
n).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
=
0: ?m.148465
0
| 0 =>
rfl: βˆ€ {Ξ± : Sort ?u.148496} {a : Ξ±}, a = a
rfl
| n+1 =>

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
ofNat_zero: βˆ€ {w : β„•}, Bitvec.ofNat w 0 = 0
ofNat_zero
:
Bitvec.ofNat: (n : β„•) β†’ β„• β†’ Bitvec n
Bitvec.ofNat
w: ?m.149369
w
0: ?m.149374
0
=
0: ?m.149385
0
:=

Goals accomplished! πŸ™

0 = 0

Goals accomplished! πŸ™
@[simp] theorem
toZMod_zero: βˆ€ {n : β„•}, toZMod 0 = 0
toZMod_zero
: βˆ€ {n :
Nat: Type
Nat
}, (
0: ?m.149459
0
:
Bitvec: β„• β†’ Type
Bitvec
n).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
=
0: ?m.149507
0
:=

Goals accomplished! πŸ™

βˆ€ {n : β„•}, toZMod 0 = 0

Goals accomplished! πŸ™
@[simp] theorem
ofZMod_zero: βˆ€ {n : β„•}, ofZMod 0 = 0
ofZMod_zero
:
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod
(
0: ?m.151433
0
:
ZMod: β„• β†’ Type
ZMod
(
2: ?m.151361
2
^
n: ?m.151351
n
)) =
0: ?m.151736
0
:=

Goals accomplished! πŸ™

0 = 0

Goals accomplished! πŸ™
theorem
toList_one: βˆ€ {n : β„•}, Vector.toList 1 = List.replicate n false ++ [true]
toList_one
{n :
β„•: Type
β„•
} : (
1: ?m.151914
1
:
Bitvec: β„• β†’ Type
Bitvec
(n +
1: ?m.151853
1
)).
toList: {Ξ± : Type ?u.151938} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
=
List.replicate: {Ξ± : Type ?u.151949} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate
n
false: Bool
false
++ [
true: Bool
true
] :=
rfl: βˆ€ {Ξ± : Sort ?u.151995} {a : Ξ±}, a = a
rfl
theorem
toNat_one: βˆ€ {n : β„•}, Bitvec.toNat 1 = if n = 0 then 0 else 1
toNat_one
: βˆ€ {n :
Nat: Type
Nat
}, (
1: ?m.152071
1
:
Bitvec: β„• β†’ Type
Bitvec
n).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
= if n =
0: ?m.152104
0
then
0: ?m.152129
0
else
1: ?m.152140
1
| 0 =>
rfl: βˆ€ {Ξ± : Sort ?u.152183} {a : Ξ±}, a = a
rfl
| 1 =>
rfl: βˆ€ {Ξ± : Sort ?u.152234} {a : Ξ±}, a = a
rfl
| n+2 =>

Goals accomplished! πŸ™

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1
n: β„•

this: Bitvec.toNat 1 = if n + 1 = 0 then 0 else 1


Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1

Goals accomplished! πŸ™
@[simp] theorem
toZMod_one: βˆ€ {n : β„•}, toZMod 1 = 1
toZMod_one
: βˆ€ {n :
Nat: Type
Nat
}, (
1: ?m.155230
1
:
Bitvec: β„• β†’ Type
Bitvec
n).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
=
1: ?m.155278
1
:=

Goals accomplished! πŸ™

βˆ€ {n : β„•}, toZMod 1 = 1

Goals accomplished! πŸ™
@[simp] theorem
ofZMod_one: βˆ€ {n : β„•}, ofZMod 1 = 1
ofZMod_one
:
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod
(
1: ?m.159402
1
:
ZMod: β„• β†’ Type
ZMod
(
2: ?m.159330
2
^
n: ?m.159320
n
)) =
1: ?m.159615
1
:=

Goals accomplished! πŸ™

1 = 1

Goals accomplished! πŸ™
instance: {n : β„•} β†’ SMul β„• (Bitvec n)
instance
:
SMul: Type ?u.159731 β†’ Type ?u.159730 β†’ Type (max?u.159731?u.159730)
SMul
β„•: Type
β„•
(
Bitvec: β„• β†’ Type
Bitvec
n: ?m.159727
n
) := ⟨
nsmulRec: {M : Type ?u.159743} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ β„• β†’ M β†’ M
nsmulRec
⟩ theorem
nsmul_def: βˆ€ {n : β„•} (x : Bitvec n) (y : β„•), y β€’ x = nsmulRec y x
nsmul_def
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n) (y :
β„•: Type
β„•
) : y β€’
x: Bitvec n
x
=
nsmulRec: {M : Type ?u.160058} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ β„• β†’ M β†’ M
nsmulRec
y
x: Bitvec n
x
:=
rfl: βˆ€ {Ξ± : Sort ?u.160090} {a : Ξ±}, a = a
rfl
@[simp] theorem
toZMod_nsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„•), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_nsmul
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n) (y :
β„•: Type
β„•
) : (y β€’
x: Bitvec n
x
).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
= y β€’
x: Bitvec n
x
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
:=

Goals accomplished! πŸ™

Goals accomplished! πŸ™

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
toInt_sub_aux: βˆ€ {x y : List Bool}, List.length x = List.length y β†’ (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0) = ↑(List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 y)
toInt_sub_aux
: βˆ€ {x y :
List: Type ?u.164902 β†’ Type ?u.164902
List
Bool: Type
Bool
} (_hx :
List.length: {Ξ± : Type ?u.164909} β†’ List Ξ± β†’ β„•
List.length
x =
List.length: {Ξ± : Type ?u.164913} β†’ List Ξ± β†’ β„•
List.length
y), (↑(
List.foldl: {Ξ± : Type ?u.164925} β†’ {Ξ² : Type ?u.164924} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.164935
0
(
List.mapAccumrβ‚‚: {Ο† : Type ?u.164948} β†’ {Οƒ : Type ?u.164947} β†’ {Ξ± : Type ?u.164946} β†’ {Ξ² : Type ?u.164945} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚
(fun
x: ?m.164954
x
y: ?m.164957
y
c: ?m.164960
c
=> (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry
(!
x: ?m.164954
x
)
y: ?m.164957
y
c: ?m.164960
c
,
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3
x: ?m.164954
x
y: ?m.164957
y
c: ?m.164960
c
)) x y
false: Bool
false
).
snd: {Ξ± : Type ?u.164979} β†’ {Ξ² : Type ?u.164978} β†’ Ξ± Γ— Ξ² β†’ Ξ²
snd
) :
β„€: Type
β„€
) -
2: ?m.165039
2
^ x.
length: {Ξ± : Type ?u.165048} β†’ List Ξ± β†’ β„•
length
*
cond: {Ξ± : Type ?u.165052} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond
(
List.mapAccumrβ‚‚: {Ο† : Type ?u.165057} β†’ {Οƒ : Type ?u.165056} β†’ {Ξ± : Type ?u.165055} β†’ {Ξ² : Type ?u.165054} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚
(fun
x: ?m.165063
x
y: ?m.165066
y
c: ?m.165069
c
=> (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry
(!
x: ?m.165063
x
)
y: ?m.165066
y
c: ?m.165069
c
,
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3
x: ?m.165063
x
y: ?m.165066
y
c: ?m.165069
c
)) x y
false: Bool
false
).
fst: {Ξ± : Type ?u.165086} β†’ {Ξ² : Type ?u.165085} β†’ Ξ± Γ— Ξ² β†’ Ξ±
fst
1: ?m.165090
1
0: ?m.165100
0
= ↑(
List.foldl: {Ξ± : Type ?u.165444} β†’ {Ξ² : Type ?u.165443} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.165454
0
x) + -↑(
List.foldl: {Ξ± : Type ?u.165488} β†’ {Ξ² : Type ?u.165487} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.165498
0
y) | [], [], _ =>
rfl: βˆ€ {Ξ± : Sort ?u.165916} {a : Ξ±}, a = a
rfl
|
a: Bool
a
::x,
b: Bool
b
::y,
h: List.length (a :: x) = List.length (b :: y)
h
=>

Goals accomplished! πŸ™

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x) + -↑((2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb 0 y)

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x) + -↑((2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb 0 y)

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x) + -(↑(2 ^ List.length y * bif b then 1 else 0) + ↑(List.foldl addLsb 0 y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x) + (-↑(2 ^ List.length y * bif b then 1 else 0) + -↑(List.foldl addLsb 0 y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).snd) - 2 ^ List.length (a :: x) * bif (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).snd) - 2 ^ List.length (a :: x) * bif (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false; let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst); (q.fst, q.snd :: r.snd)).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

(↑(List.foldl addLsb 0 (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + List.foldl addLsb 0 (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1 else 0) = ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))

false
(↑(2 ^ List.length (xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (false :: x) * bif !false && b || !false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true
(↑(2 ^ List.length (xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (true :: x) * bif !true && b || !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

false
(↑(2 ^ List.length (xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (false :: x) * bif !false && b || !false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true
(↑(2 ^ List.length (xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (true :: x) * bif !true && b || !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.false
(↑(2 ^ List.length (xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (true :: x) * bif !true && false || !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif false then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.true
(↑(2 ^ List.length (xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (true :: x) * bif !true && true || !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif true then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

false.false
(↑(2 ^ List.length (xor (xor false false) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false false) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (false :: x) * bif !false && false || !false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif false then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

false.true
(↑(2 ^ List.length (xor (xor false true) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor false true) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (false :: x) * bif !false && true || !false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif true then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.false
(↑(2 ^ List.length (xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true false) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (true :: x) * bif !true && false || !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif false then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.true
(↑(2 ^ List.length (xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor true true) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (true :: x) * bif !true && true || !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif true then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.true
↑2 ^ List.length y * ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + 2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0)) = ↑2 ^ List.length y + (-↑2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0)))

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

false.false
↑2 ^ List.length y * ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + 2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0)) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0)

false.true
-(2 ^ List.length y + 2 ^ List.length y) + (↑2 ^ List.length y * ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) + ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd)) = -↑2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0))

true.false
↑2 ^ List.length y * ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) + ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) = ↑2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0))

true.true
↑2 ^ List.length y * ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -((2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) + 2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0)) = ↑2 ^ List.length y + (-↑2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -(2 ^ List.length y * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0)))

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.false
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) * 2 ^ List.length y + ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y + 2 ^ List.length y

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

false.false
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y

false.true
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + (-((bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y) - 2 ^ List.length y)

true.false
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) * 2 ^ List.length y + ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y + 2 ^ List.length y

true.true
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) * 2 ^ List.length y

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.true.false
↑(bif false then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif false then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif false then 1 else 0) * 2 ^ List.length y

true.true.true
↑(bif true then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif true then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif true then 1 else 0) * 2 ^ List.length y

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

false.false.false
↑(bif false then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif false then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif false then 1 else 0) * 2 ^ List.length y

false.false.true
↑(bif true then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif true then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif true then 1 else 0) * 2 ^ List.length y

false.true.false
↑(bif false then 0 else 1) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + (-((bif false then 1 else 0) * 2 ^ List.length y) - 2 ^ List.length y)

false.true.true
↑(bif true then 0 else 1) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + (-((bif true then 1 else 0) * 2 ^ List.length y) - 2 ^ List.length y)

true.false.false
↑(bif false then 0 else 1) * 2 ^ List.length y + ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif false then 1 else 0) * 2 ^ List.length y + 2 ^ List.length y

true.false.true
↑(bif true then 0 else 1) * 2 ^ List.length y + ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif true then 1 else 0) * 2 ^ List.length y + 2 ^ List.length y

true.true.false
↑(bif false then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif false then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif false then 1 else 0) * 2 ^ List.length y

true.true.true
↑(bif true then 1 else 0) * 2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif true then 1 else 0) * 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - (bif true then 1 else 0) * 2 ^ List.length y

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

true.true.true
2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

false.false.true
2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y

false.true.false
2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + -2 ^ List.length y

false.true.true
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2 = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + (-2 ^ List.length y - 2 ^ List.length y)

true.false.false
2 ^ List.length y + ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) + 2 ^ List.length y

true.true.true
2 ^ List.length y + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y * 2) = ↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) - 2 ^ List.length y

(↑(2 ^ List.length (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst :: (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) * 0 + ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd * bif xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) - 2 ^ List.length (a :: x) * bif !a && b || !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst || b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0) = ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1 else 0)

Goals accomplished! πŸ™
instance: βˆ€ (n : β„•), NeZero (2 ^ n)
instance
(n :
β„•: Type
β„•
) :
NeZero: {R : Type ?u.190440} β†’ [inst : Zero R] β†’ R β†’ Prop
NeZero
(
2: ?m.190522
2
^ n) := ⟨
Nat.pos_iff_ne_zero: βˆ€ {n : β„•}, 0 < n ↔ n β‰  0
Nat.pos_iff_ne_zero
.
1: βˆ€ {a b : Prop}, (a ↔ b) β†’ a β†’ b
1
<|
pow_pos: βˆ€ {Ξ± : Type ?u.190698} [inst : StrictOrderedSemiring Ξ±] {a : Ξ±}, 0 < a β†’ βˆ€ (n : β„•), 0 < a ^ n
pow_pos
(

Goals accomplished! πŸ™

0 < 2

Goals accomplished! πŸ™
) _⟩ theorem
toZMod_sbb: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (sbb x y false).snd = toZMod x - toZMod y
toZMod_sbb
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n) : (
x: Bitvec n
x
.
sbb: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bool β†’ Bool Γ— Bitvec n
sbb
y: Bitvec n
y
false: Bool
false
).
2: {Ξ± : Type ?u.190815} β†’ {Ξ² : Type ?u.190814} β†’ Ξ± Γ— Ξ² β†’ Ξ²
2
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
=
x: Bitvec n
x
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
-
y: Bitvec n
y
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
:=

Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n


toZMod (sbb x y false).snd = toZMod x - toZMod y

mk
toZMod (sbb { val := x, property := hx } y false).snd = toZMod { val := x, property := hx } - toZMod y
n: β„•

x, y: Bitvec n


toZMod (sbb x y false).snd = toZMod x - toZMod y

mk.mk
toZMod (sbb { val := x, property := hx } { val := y, property := hy } false).snd = toZMod { val := x, property := hx } - toZMod { val := y, property := hy }
n: β„•

x, y: Bitvec n


toZMod (sbb x y false).snd = toZMod x - toZMod y

mk.mk
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) = ↑(List.foldl addLsb 0 x) - ↑(List.foldl addLsb 0 y)
n: β„•

x, y: Bitvec n


toZMod (sbb x y false).snd = toZMod x - toZMod y

mk.mk
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) = ↑(List.foldl addLsb 0 x) - ↑(List.foldl addLsb 0 y)

Goals accomplished! πŸ™

2 ^ n = 0

2 ^ n = 0

↑2 ^ n = 0

2 ^ n = 0

↑(2 ^ n) = 0

2 ^ n = 0

0 = 0

Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n


toZMod (sbb x y false).snd = toZMod x - toZMod y
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

h2n: 2 ^ n = 0

this: ↑(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) - 2 ^ List.length x * bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0) = ↑(↑(List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 y))


mk.mk
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) = ↑(List.foldl addLsb 0 x) - ↑(List.foldl addLsb 0 y)
n: β„•

x, y: Bitvec n


toZMod (sbb x y false).snd = toZMod x - toZMod y

Goals accomplished! πŸ™
theorem
toZMod_sub: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x - y) = toZMod x - toZMod y
toZMod_sub
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n) : (
x: Bitvec n
x
-
y: Bitvec n
y
).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
=
x: Bitvec n
x
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
-
y: Bitvec n
y
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
:=
toZMod_sbb: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (sbb x y false).snd = toZMod x - toZMod y
toZMod_sbb
x: Bitvec n
x
y: Bitvec n
y
theorem
toInt_neg_aux: βˆ€ (x : List Bool), (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 x)
toInt_neg_aux
: βˆ€ (x :
List: Type ?u.199365 β†’ Type ?u.199365
List
Bool: Type
Bool
), ((
List.foldl: {Ξ± : Type ?u.199375} β†’ {Ξ² : Type ?u.199374} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
(
0: ?m.199386
0
:
β„•: Type
β„•
) (
List.mapAccumr: {Οƒ : Type ?u.199398} β†’ {Ξ± : Type ?u.199397} β†’ {Ξ² : Type ?u.199396} β†’ (Ξ± β†’ Οƒ β†’ Οƒ Γ— Ξ²) β†’ List Ξ± β†’ Οƒ β†’ Οƒ Γ— List Ξ²
List.mapAccumr
(fun
y: ?m.199403
y
c: ?m.199406
c
=> (
y: ?m.199403
y
||
c: ?m.199406
c
,
xor: Bool β†’ Bool β†’ Bool
xor
y: ?m.199403
y
c: ?m.199406
c
)) x
false: Bool
false
).
snd: {Ξ± : Type ?u.199424} β†’ {Ξ² : Type ?u.199423} β†’ Ξ± Γ— Ξ² β†’ Ξ²
snd
:
β„•: Type
β„•
) -
2: ?m.199434
2
^ x.
length: {Ξ± : Type ?u.199443} β†’ List Ξ± β†’ β„•
length
*
cond: {Ξ± : Type ?u.199447} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond
(
List.mapAccumr: {Οƒ : Type ?u.199451} β†’ {Ξ± : Type ?u.199450} β†’ {Ξ² : Type ?u.199449} β†’ (Ξ± β†’ Οƒ β†’ Οƒ Γ— Ξ²) β†’ List Ξ± β†’ Οƒ β†’ Οƒ Γ— List Ξ²
List.mapAccumr
(fun
y: ?m.199456
y
c: ?m.199459
c
=> (
y: ?m.199456
y
||
c: ?m.199459
c
,
xor: Bool β†’ Bool β†’ Bool
xor
y: ?m.199456
y
c: ?m.199459
c
)) x
false: Bool
false
).
fst: {Ξ± : Type ?u.199474} β†’ {Ξ² : Type ?u.199473} β†’ Ξ± Γ— Ξ² β†’ Ξ±
fst
1: ?m.199478
1
0: ?m.199488
0
:
β„€: Type
β„€
) = -(
List.foldl: {Ξ± : Type ?u.199881} β†’ {Ξ² : Type ?u.199880} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl
addLsb: β„• β†’ Bool β†’ β„•
addLsb
0: ?m.199891
0
x) | [] =>
rfl: βˆ€ {Ξ± : Sort ?u.200249} {a : Ξ±}, a = a
rfl
|
a: Bool
a
::x =>

Goals accomplished! πŸ™

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(List.foldl addLsb 0 (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst :: (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(List.foldl addLsb 0 (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst :: (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑((2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd * bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(List.foldl addLsb 0 (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst :: (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑((2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd * bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x)

(↑(List.foldl addLsb 0 (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst :: (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd * bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x)

(↑(List.foldl addLsb 0 (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst :: (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd * bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x))

(↑(List.foldl addLsb 0 (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst :: (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd * bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(2 ^ List.length x * bif a then 1 else 0) + -↑(List.foldl addLsb 0 x)

(↑(List.foldl addLsb 0 (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst :: (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd * bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(2 ^ List.length x * bif a then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd * bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -↑(2 ^ List.length x * bif a then 1 else 0) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif a then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) - 2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) = -↑(List.foldl addLsb 0 (a :: x))

false
(2 ^ List.length x * ↑(bif xor false (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif false || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif false then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

true
(2 ^ List.length x * ↑(bif xor true (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif true || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif true then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif a then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

false
(2 ^ List.length x * ↑(bif xor false (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif false || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif false then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

true
(2 ^ List.length x * ↑(bif xor true (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif true || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif true then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif a then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

true.false
(2 ^ List.length x * ↑(bif xor true false then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif true || false then 1 else 0) = -(2 ^ List.length x * ↑(bif true then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif false then 1 else 0)

true.true
(2 ^ List.length x * ↑(bif xor true true then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif true || true then 1 else 0) = -(2 ^ List.length x * ↑(bif true then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif true then 1 else 0)

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif a then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

false.false
(2 ^ List.length x * ↑(bif xor false false then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif false || false then 1 else 0) = -(2 ^ List.length x * ↑(bif false then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif false then 1 else 0)

false.true
(2 ^ List.length x * ↑(bif xor false true then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif false || true then 1 else 0) = -(2 ^ List.length x * ↑(bif false then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif true then 1 else 0)

true.false
(2 ^ List.length x * ↑(bif xor true false then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif true || false then 1 else 0) = -(2 ^ List.length x * ↑(bif true then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif false then 1 else 0)

true.true
(2 ^ List.length x * ↑(bif xor true true then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif true || true then 1 else 0) = -(2 ^ List.length x * ↑(bif true then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif true then 1 else 0)

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif a then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

true.false
2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + (-2 ^ List.length x + -2 ^ List.length x) = -2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif a then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

false.true
2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + (-2 ^ List.length x + -2 ^ List.length x) = ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + -2 ^ List.length x

true.false
2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + (-2 ^ List.length x + -2 ^ List.length x) = -2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)

true.true
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + (-2 ^ List.length x + -2 ^ List.length x) = -2 ^ List.length x + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + -2 ^ List.length x)

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = -(2 ^ List.length x * ↑(bif a then 1 else 0)) + (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)

Goals accomplished! πŸ™
theorem
toZMod_neg: βˆ€ {n : β„•} (x : Bitvec n), toZMod (-x) = -toZMod x
toZMod_neg
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n) : (-
x: Bitvec n
x
).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
= -
x: Bitvec n
x
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
:=

Goals accomplished! πŸ™

mk
toZMod (Bitvec.neg { val := x, property := hx }) = -toZMod { val := x, property := hx }

mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)

mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)

Goals accomplished! πŸ™

2 ^ n = 0

2 ^ n = 0

↑2 ^ n = 0

2 ^ n = 0

↑(2 ^ n) = 0

2 ^ n = 0

0 = 0

Goals accomplished! πŸ™
n: β„•

x: List Bool

hx: List.length x = n

h2n: 2 ^ n = 0

this: ↑(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = ↑(-↑(List.foldl addLsb 0 x))


mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)
x: List Bool

h2n: 2 ^ List.length x = 0

this: ↑(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) - 2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) = ↑(-↑(List.foldl addLsb 0 x))


mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)

Goals accomplished! πŸ™
instance: {n : β„•} β†’ SMul β„€ (Bitvec n)
instance
:
SMul: Type ?u.225481 β†’ Type ?u.225480 β†’ Type (max?u.225481?u.225480)
SMul
β„€: Type
β„€
(
Bitvec: β„• β†’ Type
Bitvec
n: ?m.225477
n
) := ⟨
zsmulRec: {M : Type ?u.225493} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ [inst : Neg M] β†’ β„€ β†’ M β†’ M
zsmulRec
⟩ theorem
zsmul_def: βˆ€ {n : β„•} (x : Bitvec n) (y : β„€), y β€’ x = zsmulRec y x
zsmul_def
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n) (y :
β„€: Type
β„€
) : y β€’
x: Bitvec n
x
=
zsmulRec: {M : Type ?u.225880} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ [inst : Neg M] β†’ β„€ β†’ M β†’ M
zsmulRec
y
x: Bitvec n
x
:=
rfl: βˆ€ {Ξ± : Sort ?u.225923} {a : Ξ±}, a = a
rfl
@[simp] theorem
toZMod_zsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„€), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_zsmul
{n :
β„•: Type
β„•
} (
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n) (y :
β„€: Type
β„€
) : (y β€’
x: Bitvec n
x
).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
= y β€’
x: Bitvec n
x
.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
:=

Goals accomplished! πŸ™

Goals accomplished! πŸ™

Goals accomplished! πŸ™
instance: {n : β„•} β†’ AddCommGroup (Bitvec n)
instance
:
AddCommGroup: Type ?u.230846 β†’ Type ?u.230846
AddCommGroup
(
Bitvec: β„• β†’ Type
Bitvec
n: ?m.230843
n
) :=
Function.Injective.addCommGroup: {M₁ : Type ?u.230850} β†’ {Mβ‚‚ : Type ?u.230849} β†’ [inst : Add M₁] β†’ [inst_1 : Zero M₁] β†’ [inst_2 : SMul β„• M₁] β†’ [inst_3 : Neg M₁] β†’ [inst_4 : Sub M₁] β†’ [inst_5 : SMul β„€ M₁] β†’ [inst_6 : AddCommGroup Mβ‚‚] β†’ (f : M₁ β†’ Mβ‚‚) β†’ Function.Injective f β†’ f 0 = 0 β†’ (βˆ€ (x y : M₁), f (x + y) = f x + f y) β†’ (βˆ€ (x : M₁), f (-x) = -f x) β†’ (βˆ€ (x y : M₁), f (x - y) = f x - f y) β†’ (βˆ€ (x : M₁) (n : β„•), f (n β€’ x) = n β€’ f x) β†’ (βˆ€ (x : M₁) (n : β„€), f (n β€’ x) = n β€’ f x) β†’ AddCommGroup M₁
Function.Injective.addCommGroup
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod
(
Function.injective_iff_hasLeftInverse: βˆ€ {Ξ± : Sort ?u.231282} {Ξ² : Sort ?u.231283} [inst : Nonempty Ξ±] {f : Ξ± β†’ Ξ²}, Function.Injective f ↔ Function.HasLeftInverse f
Function.injective_iff_hasLeftInverse
.
2: βˆ€ {a b : Prop}, (a ↔ b) β†’ b β†’ a
2
⟨
_: ?m.231348
_
,
ofZMod_toZMod: βˆ€ {n : β„•} (v : Bitvec n), ofZMod (toZMod v) = v
ofZMod_toZMod
⟩)
toZMod_zero: βˆ€ {n : β„•}, toZMod 0 = 0
toZMod_zero
toZMod_add: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x + y) = toZMod x + toZMod y
toZMod_add
toZMod_neg: βˆ€ {n : β„•} (x : Bitvec n), toZMod (-x) = -toZMod x
toZMod_neg
toZMod_sub: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x - y) = toZMod x - toZMod y
toZMod_sub
toZMod_nsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„•), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_nsmul
toZMod_zsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„€), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_zsmul
-- see https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Pattern.20matching.20subtypes def
add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
add?
{n :
Nat: Type
Nat
} (
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n) :
Option: Type ?u.232586 β†’ Type ?u.232586
Option
(
Bitvec: β„• β†’ Type
Bitvec
n) := match
Bitvec.adc: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bool β†’ Bitvec (n + 1)
Bitvec.adc
x: Bitvec n
x
y: Bitvec n
y
false: Bool
false
with | ⟨
false: Bool
false
:: z,
hcons: List.length (false :: z) = n + 1
hcons
⟩ =>
some: {Ξ± : Type ?u.232636} β†’ Ξ± β†’ Option Ξ±
some
⟨z,

Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

z: List Bool

hcons: List.length (false :: z) = n + 1



Goals accomplished! πŸ™
⟩ | _ =>
none: {Ξ± : Type ?u.232657} β†’ Option Ξ±
none
-- overflow theorem
Warning: declaration uses 'sorry'
{n :
Nat: Type
Nat
} {
x: Bitvec n
x
y: Bitvec n
y
z: Bitvec n
z
:
Bitvec: β„• β†’ Type
Bitvec
n} :
add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
add?
x: Bitvec n
x
y: Bitvec n
y
=
some: {Ξ± : Type ?u.233476} β†’ Ξ± β†’ Option Ξ±
some
z: Bitvec n
z
β†’
x: Bitvec n
x
+
y: Bitvec n
y
=
z: Bitvec n
z
:=
sorry: ?m.233532
sorry
/- #eval (𝟷𝟢𝟷𝟷).toNat * (𝟷𝟢𝟷𝟷).toNat #eval Bitvec.mul (𝟷𝟢𝟷𝟷) (𝟷𝟢𝟷𝟷) |>.toNat -/ protected def
mul?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
mul?
{n :
Nat: Type
Nat
} (
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n) :
Option: Type ?u.233547 β†’ Type ?u.233547
Option
(
Bitvec: β„• β†’ Type
Bitvec
n) := do let
f: (r : ?m.233571) β†’ (b : ?m.233579 r) β†’ ?m.233580 r b
f
r: ?m.233571
r
b: ?m.233574
b
:= do let
op₁: ?m.233736
op₁
←
Bitvec.add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
Bitvec.add?
r: ?m.233571
r
r: ?m.233571
r
let
opβ‚‚: ?m.233784
opβ‚‚
←
Bitvec.add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
Bitvec.add?
op₁: ?m.233736
op₁
y: Bitvec n
y
return
cond: {Ξ± : Type ?u.233804} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond
b: ?m.233574
b
opβ‚‚: ?m.233784
opβ‚‚
op₁: ?m.233736
op₁
(
x: Bitvec n
x
.
toList: {Ξ± : Type ?u.233583} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
).
foldlM: {m : Type ?u.233593 β†’ Type ?u.233592} β†’ [inst : Monad m] β†’ {s : Type ?u.233593} β†’ {Ξ± : Type ?u.233591} β†’ (s β†’ Ξ± β†’ m s) β†’ s β†’ List Ξ± β†’ m s
foldlM
f: (r : ?m.233571) β†’ (b : ?m.233579 r) β†’ ?m.233580 r b
f
0: ?m.233650
0
/- #eval Bitvec.mul? (𝟷𝟢𝟷𝟷) (𝟷𝟢𝟷𝟷) #eval Bitvec.mul? (𝟢𝟢𝟢𝟢𝟢𝟢𝟷𝟢𝟷𝟷) (𝟢𝟢𝟢𝟢𝟢𝟢𝟷𝟢𝟷𝟷) |>.get!|>.toNat -/ theorem
Warning: declaration uses 'sorry'
: βˆ€ {n :
Nat: Type
Nat
} {
x: Bitvec n
x
y: Bitvec n
y
z: Bitvec n
z
:
Bitvec: β„• β†’ Type
Bitvec
n},
Bitvec.mul?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
Bitvec.mul?
x: Bitvec n
x
y: Bitvec n
y
=
some: {Ξ± : Type ?u.234279} β†’ Ξ± β†’ Option Ξ±
some
z: Bitvec n
z
β†’
x: Bitvec n
x
*
y: Bitvec n
y
=
z: Bitvec n
z
:=
sorry: ?m.234343
sorry
/-- The value produced is the unsigned integer quotient of the two operands. Note that unsigned integer division and signed integer division are distinct operations; for signed integer division, use β€˜sdiv’. Division by zero is undefined behavior. -/ def
udiv?: {w : β„•} β†’ Bitvec w β†’ Bitvec w β†’ Option (Bitvec w)
udiv?
{w :
Nat: Type
Nat
} (
x: Bitvec w
x
y: Bitvec w
y
:
Bitvec: β„• β†’ Type
Bitvec
w) :
Option: Type ?u.234362 β†’ Type ?u.234362
Option
$
Bitvec: β„• β†’ Type
Bitvec
w := match
y: Bitvec w
y
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
with | 0 =>
none: {Ξ± : Type ?u.234389} β†’ Option Ξ±
none
| _ =>
some: {Ξ± : Type ?u.234399} β†’ Ξ± β†’ Option Ξ±
some
$
Bitvec.ofNat: (n : β„•) β†’ β„• β†’ Bitvec n
Bitvec.ofNat
w (
x: Bitvec w
x
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
/
y: Bitvec w
y
.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
) /-- The value produced is the signed integer quotient of the two operands rounded towards zero. Note that signed integer division and unsigned integer division are distinct operations; for unsigned integer division, use β€˜udiv’. Division by zero is undefined behavior. Overflow also leads to undefined behavior; this is a rare case, but can occur, for example, by doing a 32-bit division of -2147483648 by -1. -/ def
sdiv?: {w : β„•} β†’ Bitvec w β†’ Bitvec w β†’ Option (Bitvec w)
sdiv?
{w :
Nat: Type
Nat
} (
x: Bitvec w
x
y: Bitvec w
y
:
Bitvec: β„• β†’ Type
Bitvec
w) :
Option: Type ?u.234723 β†’ Type ?u.234723
Option
$
Bitvec: β„• β†’ Type
Bitvec
w := if
y: Bitvec w
y
.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt
=
0: ?m.234734
0
then
none: {Ξ± : Type ?u.234772} β†’ Option Ξ±
none
else
some: {Ξ± : Type ?u.234775} β†’ Ξ± β†’ Option Ξ±
some
$
Bitvec.ofInt': (n : β„•) β†’ β„€ β†’ Bitvec n
Bitvec.ofInt'
w (
x: Bitvec w
x
.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt
/
y: Bitvec w
y
.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt
) /-- If the condition is an i1 and it evaluates to 1, the instruction returns the first value argument; otherwise, it returns the second value argument. -/ def
select: {w : β„•} β†’ Bitvec 1 β†’ Bitvec w β†’ Bitvec w β†’ Bitvec w
select
{w :
Nat: Type
Nat
} (
c: Bitvec 1
c
:
Bitvec: β„• β†’ Type
Bitvec
1: ?m.234951
1
) (
x: Bitvec w
x
y: Bitvec w
y
:
Bitvec: β„• β†’ Type
Bitvec
w) :
Bitvec: β„• β†’ Type
Bitvec
w :=
cond: {Ξ± : Type ?u.234976} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond
c: Bitvec 1
c
.
head: {Ξ± : Type ?u.234978} β†’ {n : β„•} β†’ Vector Ξ± (Nat.succ n) β†’ Ξ±
head
x: Bitvec w
x
y: Bitvec w
y
theorem
bitwise_eq_eq: βˆ€ {w : β„•} {x y : Bitvec w}, (βˆ€ (i : Fin w), x[i] = y[i]) ↔ x = y
bitwise_eq_eq
{w :
Nat: Type
Nat
} {
x: Bitvec w
x
y: Bitvec w
y
:
Bitvec: β„• β†’ Type
Bitvec
w} : (forall
i: Fin w
i
:
Fin: β„• β†’ Type
Fin
w,
x: Bitvec w
x
[
i: Fin w
i
] =
y: Bitvec w
y
[
i: Fin w
i
]) ↔
x: Bitvec w
x
=
y: Bitvec w
y
:= ⟨
Vector.ext: βˆ€ {n : β„•} {Ξ± : Type ?u.235454} {v w : Vector Ξ± n}, (βˆ€ (m : Fin n), Vector.get v m = Vector.get w m) β†’ v = w
Vector.ext
, fun
h: ?m.235489
h
_: ?m.235492
_
=>
h: ?m.235489
h
β–Έ
rfl: βˆ€ {Ξ± : Sort ?u.235494} {a : Ξ±}, a = a
rfl
⟩ theorem
ext_get?: βˆ€ {w : β„•} {x y : Bitvec w}, (βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i) β†’ x = y
ext_get?
{w :
Nat: Type
Nat
} {
x: Bitvec w
x
y: Bitvec w
y
:
Bitvec: β„• β†’ Type
Bitvec
w} (
h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i
h
: βˆ€
i: ?m.235528
i
,
x: Bitvec w
x
.
toList: {Ξ± : Type ?u.235532} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.235537} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
i: ?m.235528
i
=
y: Bitvec w
y
.
toList: {Ξ± : Type ?u.235543} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.235546} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
i: ?m.235528
i
) :
x: Bitvec w
x
=
y: Bitvec w
y
:=

Goals accomplished! πŸ™
w: β„•

x, y: Bitvec w

h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i


x = y
x: List Bool

y: Bitvec (List.length x)

h: βˆ€ (i : β„•), List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i = List.get? (Vector.toList y) i


mk
{ val := x, property := (_ : List.length x = List.length x) } = y
w: β„•

x, y: Bitvec w

h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i


x = y
x, y: List Bool

hy: List.length y = List.length x

h: βˆ€ (i : β„•), List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i = List.get? (Vector.toList { val := y, property := hy }) i


mk.mk
{ val := x, property := (_ : List.length x = List.length x) } = { val := y, property := hy }
w: β„•

x, y: Bitvec w

h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i


x = y

Goals accomplished! πŸ™
@[simp] theorem
toList_cong: βˆ€ {w₁ wβ‚‚ : β„•} (h : w₁ = wβ‚‚) (b : Bitvec w₁), Vector.toList (Bitvec.cong h b) = Vector.toList b
toList_cong
{
w₁: β„•
w₁
wβ‚‚: β„•
wβ‚‚
:
Nat: Type
Nat
} (
h: w₁ = wβ‚‚
h
:
w₁: β„•
w₁
=
wβ‚‚: β„•
wβ‚‚
) (
b: Bitvec w₁
b
:
Bitvec: β„• β†’ Type
Bitvec
w₁: β„•
w₁
) : (
Bitvec.cong: {a b : β„•} β†’ a = b β†’ Bitvec a β†’ Bitvec b
Bitvec.cong
h: w₁ = wβ‚‚
h
b: Bitvec w₁
b
).
toList: {Ξ± : Type ?u.235705} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
=
b: Bitvec w₁
b
.
toList: {Ξ± : Type ?u.235713} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
:=

Goals accomplished! πŸ™
w₁, wβ‚‚: β„•

h: w₁ = wβ‚‚

b: Bitvec w₁


w₁: β„•

b: Bitvec w₁


Vector.toList (Bitvec.cong (_ : w₁ = w₁) b) = Vector.toList b
w₁: β„•

b: Bitvec w₁


Vector.toList (Bitvec.cong (_ : w₁ = w₁) b) = Vector.toList b
w₁, wβ‚‚: β„•

h: w₁ = wβ‚‚

b: Bitvec w₁



Goals accomplished! πŸ™
theorem
get?_shl: βˆ€ {n : β„•} (x : Bitvec n) (i j : β„•), List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
get?_shl
(
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.235775
n
) (i j :
β„•: Type
β„•
) : (
x: Bitvec n
x
.
shl: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
shl
i).
toList: {Ξ± : Type ?u.235790} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.235795} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
j = if i + j <
n: ?m.235775
n
then
x: Bitvec n
x
.
toList: {Ξ± : Type ?u.235851} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.235854} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
(i + j) else if j <
n: ?m.235775
n
then
false: Bool
false
else
none: {Ξ± : Type ?u.235984} β†’ Option Ξ±
none
:=

Goals accomplished! πŸ™
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (Bitvec.cong (_ : n - i + min n i = n) (Vector.append (Vector.drop i x) (Vector.replicate (min n i) false)))) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool


mk
List.get? (Vector.toList (Bitvec.cong (_ : List.length x - i + min (List.length x) i = List.length x) (Vector.append (Vector.drop i { val := x, property := (_ : List.length x = List.length x) }) (Vector.replicate (min (List.length x) i) false)))) j = if i + j < List.length x then List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) (i + j) else if j < List.length x then some false else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool


mk
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = if i + j < List.length x then List.get? x (i + j) else if j < List.length x then some false else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
List.get? (List.drop i x) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
List.get? x (i + j) = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl
i, j: β„•

x: List Bool

h₁: i + j < List.length x


mk.inl

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
some (List.get (List.replicate (min (List.length x) i) false) { val := j - List.length (List.drop i x), isLt := ?mk.inr.inl }) = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x



Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl

Goals accomplished! πŸ™

Goals accomplished! πŸ™

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x


mk.inr.inl

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (shl x i)) j = if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x


mk.inr.inr

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
get?_ushr: βˆ€ {n : β„•} (x : Bitvec n) (i j : β„•), List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
get?_ushr
(
x: Bitvec n
x
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.243378
n
) (i j :
β„•: Type
β„•
) : (
x: Bitvec n
x
.
ushr: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
ushr
i).
toList: {Ξ± : Type ?u.243393} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.243398} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
j = if j <
x: Bitvec n
x
.
length: {Ξ± : Type ?u.243405} β†’ {n : β„•} β†’ Vector Ξ± n β†’ β„•
length
then if j < i then
some: {Ξ± : Type ?u.243438} β†’ Ξ± β†’ Option Ξ±
some
false: Bool
false
else
x: Bitvec n
x
.
toList: {Ξ± : Type ?u.243441} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.243444} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
(j - i) else
none: {Ξ± : Type ?u.243491} β†’ Option Ξ±
none
:=

Goals accomplished! πŸ™
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (fillShr x i false)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool


mk
List.get? (Vector.toList (fillShr { val := x, property := (_ : List.length x = List.length x) } i false)) j = if j < Vector.length { val := x, property := (_ : List.length x = List.length x) } then if j < i then some false else List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) (j - i) else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool


mk
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = if j < Vector.length { val := x, property := (_ : List.length x = List.length x) } then if j < i then some false else List.get? x (j - i) else none
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
some (List.get (List.replicate (min (List.length x) i) false) { val := j, isLt := ?mk.inl.inl }) = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i


mk.inl.inl

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x



Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x



Goals accomplished! πŸ™

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i


mk.inl.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x


mk.inl.inr

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
n: β„•

x: Bitvec n

i, j: β„•


List.get? (Vector.toList (ushr x i)) j = if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: List.length x ≀ i


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: List.length x ≀ i


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: List.length x ≀ i


mk.inr.inl
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i


mk.inr.inr

Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }


mk.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i


mk.inr.inr
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i


mk.inr.inr

Goals accomplished! πŸ™

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
get?_and: βˆ€ {n : β„•} (x y : Bitvec n) (i : β„•), List.get? (Vector.toList (Bitvec.and x y)) i = do let __do_lift ← List.get? (Vector.toList x) i let __do_lift_1 ← List.get? (Vector.toList y) i pure (__do_lift && __do_lift_1)
get?_and
(
x: Bitvec n
x
y: Bitvec n
y
:
Bitvec: β„• β†’ Type
Bitvec
n: ?m.261948
n
) (i :
β„•: Type
β„•
) : (
x: Bitvec n
x
.
and: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
and
y: Bitvec n
y
).
toList: {Ξ± : Type ?u.261963} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.261968} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
i = do return
(← x.toList.get? i): ?m.262050
(←
x: Bitvec n
x
(← x.toList.get? i): ?m.262050
.
toList: {Ξ± : Type ?u.262040} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
(← x.toList.get? i): ?m.262050
.
get?: {Ξ± : Type ?u.262043} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
(← x.toList.get? i): ?m.262050
i
(← x.toList.get? i): ?m.262050
)
&&
(← y.toList.get? i): ?m.262105
(←
y: Bitvec n
y
(← y.toList.get? i): ?m.262105
.
toList: {Ξ± : Type ?u.262096} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
(← y.toList.get? i): ?m.262105
.
get?: {Ξ± : Type ?u.262099} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
(← y.toList.get? i): ?m.262105
i
(← y.toList.get? i): ?m.262105
)
:=

Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

i: β„•


List.get? (Vector.toList (Bitvec.and x y)) i = do let __do_lift ← List.get? (Vector.toList x) i let __do_lift_1 ← List.get? (Vector.toList y) i pure (__do_lift && __do_lift_1)

mk
List.get? (Vector.toList (Bitvec.and { val := x, property := (_ : List.length x = List.length x) } y)) i = do let __do_lift ← List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i let __do_lift_1 ← List.get? (Vector.toList y) i pure (__do_lift && __do_lift_1)
n: β„•

x, y: Bitvec n

i: β„•


List.get? (Vector.toList (Bitvec.and x y)) i = do let __do_lift ← List.get? (Vector.toList x) i let __do_lift_1 ← List.get? (Vector.toList y) i pure (__do_lift && __do_lift_1)

mk.mk
List.get? (Vector.toList (Bitvec.and { val := x, property := (_ : List.length x = List.length x) } { val := y, property := hy })) i = do let __do_lift ← List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i let __do_lift_1 ← List.get? (Vector.toList { val := y, property := hy }) i pure (__do_lift && __do_lift_1)
n: β„•

x, y: Bitvec n

i: β„•


List.get? (Vector.toList (Bitvec.and x y)) i = do let __do_lift ← List.get? (Vector.toList x) i let __do_lift_1 ← List.get? (Vector.toList y) i pure (__do_lift && __do_lift_1)

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do let __do_lift ← List.get? x i let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)
n: β„•

x, y: Bitvec n

i: β„•


List.get? (Vector.toList (Bitvec.and x y)) i = do let __do_lift ← List.get? (Vector.toList x) i let __do_lift_1 ← List.get? (Vector.toList y) i pure (__do_lift && __do_lift_1)

mk.mk.none
(Option.bind (Option.map and none) fun g => Option.map g (List.get? y i)) = do let __do_lift ← none let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool


mk.mk.some
(Option.bind (Option.map and (some val✝)) fun g => Option.map g (List.get? y i)) = do let __do_lift ← some val✝ let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do let __do_lift ← List.get? x i let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)

mk.mk.none
(Option.bind (Option.map and none) fun g => Option.map g (List.get? y i)) = do let __do_lift ← none let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool


mk.mk.some
(Option.bind (Option.map and (some val✝)) fun g => Option.map g (List.get? y i)) = do let __do_lift ← some val✝ let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do let __do_lift ← List.get? x i let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)

mk.mk.none.none
(Option.bind (Option.map and none) fun g => Option.map g none) = do let __do_lift ← none let __do_lift_1 ← none pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool


mk.mk.none.some
(Option.bind (Option.map and none) fun g => Option.map g (some val✝)) = do let __do_lift ← none let __do_lift_1 ← some val✝ pure (__do_lift && __do_lift_1)

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do let __do_lift ← List.get? x i let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)

mk.mk.none.none
(Option.bind (Option.map and none) fun g => Option.map g none) = do let __do_lift ← none let __do_lift_1 ← none pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool


mk.mk.none.some
(Option.bind (Option.map and none) fun g => Option.map g (some val✝)) = do let __do_lift ← none let __do_lift_1 ← some val✝ pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool


mk.mk.some.none
(Option.bind (Option.map and (some val✝)) fun g => Option.map g none) = do let __do_lift ← some val✝ let __do_lift_1 ← none pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝¹, val✝: Bool


mk.mk.some.some
(Option.bind (Option.map and (some val✝¹)) fun g => Option.map g (some val✝)) = do let __do_lift ← some val✝¹ let __do_lift_1 ← some val✝ pure (__do_lift && __do_lift_1)

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do let __do_lift ← List.get? x i let __do_lift_1 ← List.get? y i pure (__do_lift && __do_lift_1)

Goals accomplished! πŸ™
theorem
get?_ofInt_neg_one: βˆ€ {w i : β„•}, List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
get?_ofInt_neg_one
: (
Bitvec.ofInt: (n : β„•) β†’ β„€ β†’ Bitvec (Nat.succ n)
Bitvec.ofInt
w: ?m.313213
w
(-
1: ?m.313262
1
)).
toList: {Ξ± : Type ?u.313279} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
.
get?: {Ξ± : Type ?u.313282} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
i: ?m.313256
i
= if
i: ?m.313256
i
≀
w: ?m.313213
w
then
some: {Ξ± : Type ?u.313305} β†’ Ξ± β†’ Option Ξ±
some
true: Bool
true
else
none: {Ξ± : Type ?u.313308} β†’ Option Ξ±
none
:=

Goals accomplished! πŸ™
w, i: β„•


List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•


List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•


List.get? (true :: List.replicate w true) i = if i ≀ w then some true else none
w, i: β„•


List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•


List.get? (true :: List.replicate w true) i = if i ≀ w then some true else none
w, i: β„•


List.get? (List.replicate (w + 1) true) i = if i ≀ w then some true else none
w, i: β„•


List.get? (List.replicate (w + 1) true) i = if i ≀ w then some true else none
w, i: β„•


List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: Β¬i ≀ w


inr
w, i: β„•


List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: Β¬i ≀ w


inr
w, i: β„•

h: i ≀ w


inl
some (List.get (List.replicate (w + 1) true) { val := i, isLt := ?inl }) = some true
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: i ≀ w


inl
w, i: β„•

h: i ≀ w


inl

Goals accomplished! πŸ™
w, i: β„•

h: Β¬i ≀ w


inr
w, i: β„•


List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

h: Β¬i ≀ w


inr
w, i: β„•

h: Β¬i ≀ w


inr
w, i: β„•

h: Β¬i ≀ w


inr
w, i: β„•

h: Β¬i ≀ w


inr

Goals accomplished! πŸ™

Goals accomplished! πŸ™
-- from InstCombine/Shift:279 theorem
shl_ushr_eq_and_shl: βˆ€ {w : β„•} {x C : Bitvec (Nat.succ w)}, shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
shl_ushr_eq_and_shl
{w :
Nat: Type
Nat
} {x C :
Bitvec: β„• β†’ Type
Bitvec
w.
succ: β„• β†’ β„•
succ
} :
Bitvec.shl: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
Bitvec.shl
(
Bitvec.ushr: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
Bitvec.ushr
x C.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
) C.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
=
Bitvec.and: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
Bitvec.and
x (
Bitvec.shl: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
Bitvec.shl
(
Bitvec.ofInt: (n : β„•) β†’ β„€ β†’ Bitvec (Nat.succ n)
Bitvec.ofInt
w (-
1: ?m.316004
1
)) C.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
) :=

Goals accomplished! πŸ™

h

h
(if Bitvec.toNat C + i < Nat.succ w then if Bitvec.toNat C + i < Vector.length x then if Bitvec.toNat C + i < Bitvec.toNat C then some false else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) else none else if i < Nat.succ w then some false else none) = List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i

h
(if Bitvec.toNat C + i < Nat.succ w then if Bitvec.toNat C + i < Vector.length x then if Bitvec.toNat C + i < Bitvec.toNat C then some false else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) else none else if i < Nat.succ w then some false else none) = do let __do_lift ← List.get? (Vector.toList x) i let __do_lift_1 ← List.get? (Vector.toList (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))) i pure (__do_lift && __do_lift_1)

h
(if Bitvec.toNat C + i < Nat.succ w then if Bitvec.toNat C + i < Vector.length x then if Bitvec.toNat C + i < Bitvec.toNat C then some false else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) else none else if i < Nat.succ w then some false else none) = do let __do_lift ← List.get? (Vector.toList x) i let __do_lift_1 ← List.get? (Vector.toList (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))) i pure (__do_lift && __do_lift_1)

h
(if Bitvec.toNat C + i ≀ w then if Bitvec.toNat C + i ≀ w then if Bitvec.toNat C + i < Bitvec.toNat C then some false else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) else none else if i ≀ w then some false else none) = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (if Bitvec.toNat C + i ≀ w then if Bitvec.toNat C + i ≀ w then some true else none else if i ≀ w then some false else none) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)

Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C


h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)

Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (some (List.get (Vector.toList x) { val := i, isLt := ?h.inr.inl })) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (some (List.get (Vector.toList x) { val := i, isLt := ?h.inr.inl })) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (some (List.get (Vector.toList x) { val := i, isLt := ?h.inr.inl })) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w


h.inr.inl
some false = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)

Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind none fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind none fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind none fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)

Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: w < Bitvec.toNat C + i

h₃: w < i


h.inr.inr
w < i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w


h.inr.inr
none = Option.bind (List.get? (Vector.toList x) i) fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
toInt_injective: βˆ€ {w : β„•}, Function.Injective Bitvec.toInt
toInt_injective
: βˆ€ {w :
Nat: Type
Nat
},
Function.Injective: {Ξ± : Sort ?u.331618} β†’ {Ξ² : Sort ?u.331617} β†’ (Ξ± β†’ Ξ²) β†’ Prop
Function.Injective
(
Bitvec.toInt: {n : β„•} β†’ Bitvec n β†’ β„€
Bitvec.toInt
:
Bitvec: β„• β†’ Type
Bitvec
w β†’
β„€: Type
β„€
) | 0, ⟨[],
_: List.length [] = 0
_
⟩, ⟨[], _⟩,
rfl: βˆ€ {Ξ± : Sort ?u.331651} {a : Ξ±}, a = a
rfl
=>
rfl: βˆ€ {Ξ± : Sort ?u.331746} {a : Ξ±}, a = a
rfl
| n+1, ⟨
a: Bool
a
::x,
hx: List.length (a :: x) = n + 1
hx
⟩, ⟨
b: Bool
b
::y,
hy: List.length (b :: y) = n + 1
hy
⟩,
h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }
h
=>

Goals accomplished! πŸ™
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


a
Vector.toList { val := a :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (false :: x) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


a.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (true :: x) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


a.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


a
Vector.toList { val := a :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (false :: x) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


a.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (true :: x) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


a.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) = bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))


a
Vector.toList { val := a :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: Bitvec.toNat { val := x, property := (_ : Nat.pred (List.length (false :: x)) = Nat.pred (Nat.succ (n + 0))) } = Bitvec.toNat { val := y, property := (_ : Nat.pred (List.length (false :: y)) = Nat.pred (Nat.succ (n + 0))) }


a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (Vector.toList ∘ Bitvec.ofNat n) (Bitvec.toNat { val := x, property := (_ : Nat.pred (List.length (false :: x)) = Nat.pred (Nat.succ (n + 0))) }) = (Vector.toList ∘ Bitvec.ofNat n) (Bitvec.toNat { val := y, property := (_ : Nat.pred (List.length (false :: y)) = Nat.pred (Nat.succ (n + 0))) })


a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }

Goals accomplished! πŸ™
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }

Goals accomplished! πŸ™
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))


a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }

Goals accomplished! πŸ™
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }


{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: Bitvec.toNat (Bitvec.not { val := x, property := (_ : Nat.pred (List.length (true :: x)) = Nat.pred (Nat.succ (n + 0))) }) = Bitvec.toNat (Bitvec.not { val := y, property := (_ : Nat.pred (List.length (true :: y)) = Nat.pred (Nat.succ (n + 0))) })


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (Vector.toList ∘ Bitvec.ofNat n) (Bitvec.toNat (Bitvec.not { val := x, property := (_ : Nat.pred (List.length (true :: x)) = Nat.pred (Nat.succ (n + 0))) })) = (Vector.toList ∘ Bitvec.ofNat n) (Bitvec.toNat (Bitvec.not { val := y, property := (_ : Nat.pred (List.length (true :: y)) = Nat.pred (Nat.succ (n + 0))) }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) = bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy }))) else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))


a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
toInt_zero: βˆ€ {w : β„•}, Bitvec.toInt 0 = 0
toInt_zero
{w :
Nat: Type
Nat
} : (
0: ?m.337976
0
:
Bitvec: β„• β†’ Type
Bitvec
w).
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt
=
0: ?m.338008
0
:=

Goals accomplished! πŸ™

(match w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

zero
(match Nat.zero, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

zero
(match Nat.zero, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

zero
(match Nat.zero, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

Goals accomplished! πŸ™

succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0
w: β„•

this✝: Vector.head 0 = false

this: Vector.tail 0 = 0


succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

succ
(match Nat.succ w, 0 with | 0, x => 0 | Nat.succ n, v => bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v))) else ↑(Bitvec.toNat (Vector.tail v))) = 0

Goals accomplished! πŸ™
@[simp] theorem
toInt_eq_zero: βˆ€ {w : β„•} (b : Bitvec w), Bitvec.toInt b = 0 ↔ b = 0
toInt_eq_zero
{w :
Nat: Type
Nat
} (
b: Bitvec w
b
:
Bitvec: β„• β†’ Type
Bitvec
w) :
b: Bitvec w
b
.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt
=
0: ?m.340676
0
↔
b: Bitvec w
b
=
0: ?m.340702
0
:=

Goals accomplished! πŸ™

Goals accomplished! πŸ™
theorem
toInt_one: βˆ€ {w : β„•}, 1 < w β†’ Bitvec.toInt 1 = 1
toInt_one
: βˆ€ {w :
β„•: Type
β„•
} (
_hw: 1 < w
_hw
:
1: ?m.340812
1
< w),
Bitvec.toInt: {n : β„•} β†’ Bitvec n β†’ β„€
Bitvec.toInt
(
1: ?m.340851
1
:
Bitvec: β„• β†’ Type
Bitvec
w) =
1: ?m.340876
1
| w+2, _ =>

Goals accomplished! πŸ™
w: β„•

x✝: 1 < w + 2


w: β„•

x✝: 1 < w + 2

this: Vector.head 1 = false


w: β„•

x✝: 1 < w + 2


w: β„•

x✝: 1 < w + 2

this✝: Vector.head 1 = false

this: Vector.tail 1 = 1


w: β„•

x✝: 1 < w + 2



Goals accomplished! πŸ™
-- from InstCombine/:805 theorem
Warning: declaration uses 'sorry'
{w :
Nat: Type
Nat
} {
x: Bitvec w
x
:
Bitvec: β„• β†’ Type
Bitvec
w} (
hw: w > 1
hw
: w >
1: ?m.343603
1
) (
hx: x β‰  0
hx
:
x: Bitvec w
x
β‰ 
0: ?m.343636
0
) :
Bitvec.sdiv?: {w : β„•} β†’ Bitvec w β†’ Bitvec w β†’ Option (Bitvec w)
Bitvec.sdiv?
1: ?m.343664
1
x: Bitvec w
x
=
Option.some: {Ξ± : Type ?u.343687} β†’ Ξ± β†’ Option Ξ±
Option.some
(
Bitvec.select: {w : β„•} β†’ Bitvec 1 β†’ Bitvec w β†’ Bitvec w β†’ Bitvec w
Bitvec.select
(((
x: Bitvec w
x
+
1: ?m.343700
1
).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat
<
3: ?m.343776
3
) ::α΅₯
Vector.nil: {Ξ± : Type ?u.343828} β†’ Vector Ξ± 0
Vector.nil
)
x: Bitvec w
x
0: ?m.343831
0
) :=

Goals accomplished! πŸ™
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0


sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0


sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)

Goals accomplished! πŸ™
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0


w β‰  0
x: Bitvec 0

hw: 0 > 1

hx: x β‰  0


x: Bitvec 0

hw: 0 > 1

hx: x β‰  0


w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0


w β‰  0

Goals accomplished! πŸ™
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0


sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

hw0: w β‰  0


ofInt' w (1 / Bitvec.toInt x) = if (Bitvec.toNat x + 1) % 2 ^ w < 3 then x else 0
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0


sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)

Goals accomplished! πŸ™
end Bitvec